package com.atguigu.gmall.product.service.impl;

import com.atguigu.gmall.model.product.BaseCategoryTrademark;
import com.atguigu.gmall.model.product.BaseTrademark;
import com.atguigu.gmall.model.product.CategoryTrademarkVo;
import com.atguigu.gmall.product.mapper.BaseCategoryTrademarkMapper;
import com.atguigu.gmall.product.mapper.BaseTrademarkMapper;
import com.atguigu.gmall.product.service.BaseCategoryTrademarkService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import sun.dc.pr.PRError;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class BaseCategoryTrademarkServiceImpl extends ServiceImpl<BaseCategoryTrademarkMapper,BaseCategoryTrademark> implements BaseCategoryTrademarkService {

    @Autowired
    private BaseTrademarkMapper baseTrademarkMapper;

    @Autowired
    private BaseCategoryTrademarkMapper baseCategoryTrademarkMapper;

    @Override
    public List<BaseTrademark> findTrademarkList(Long category3Id) {
        //根据三级分类id查询base_category_trademark 表 ，得到品牌id集合数据
        List<BaseCategoryTrademark> baseCategoryTrademarkList = baseCategoryTrademarkMapper
                .selectList(new QueryWrapper<BaseCategoryTrademark>().eq("category3_id", category3Id));

        //验证为空
        if (!CollectionUtils.isEmpty(baseCategoryTrademarkList)){
            //获取集合对象
            //map是映射    collect返回类型
            List<Long> tradeMarkIdList  = baseCategoryTrademarkList.stream().map(baseCategoryTrademark -> {
               return baseCategoryTrademark.getTrademarkId();
            }).collect(Collectors.toList());

            //根据 base_category_trademark 表中trademark_id 查询分类品牌base_trademark
            return baseTrademarkMapper.selectBatchIds(tradeMarkIdList);
        }
        //默认为空
        return null;
    }

    @Override
    public List<BaseTrademark> findCurrentTrademarkList(Long category3Id) {
        //根据三级分类id查询base_category_trademark 表 ，得到品牌id集合数据
        List<BaseCategoryTrademark> baseCategoryTrademarkList = baseCategoryTrademarkMapper
                .selectList(new QueryWrapper<BaseCategoryTrademark>().eq("category3_id", category3Id));
        //验证为空
        if (!CollectionUtils.isEmpty(baseCategoryTrademarkList)){
            //  找到关联的品牌Id 集合数据 {1,3}
            List<Long> tradeMarkIdList = baseCategoryTrademarkList.stream().map(baseCategoryTrademark -> {
                return baseCategoryTrademark.getTrademarkId();
            }).collect(Collectors.toList());

            //查询全部品牌id
            List<BaseTrademark> baseTrademarkList = baseTrademarkMapper.selectList(null);
            List<BaseTrademark> baseTrademarkLists = baseTrademarkList.stream().filter(baseTrademark -> {
                //查找不在的品牌 filter过滤  contains包含
                return !tradeMarkIdList.contains(baseTrademark.getId());
            }).collect(Collectors.toList());
            return baseTrademarkLists;
        }
        //  如果说这个三级分类Id 下 没有任何品牌！ 则获取到所有的品牌数据！
        return baseTrademarkMapper.selectList(null);
    }

    @Override
    public void removeById(Long category3Id, Long trademarkId) {
        baseCategoryTrademarkMapper.delete(new QueryWrapper<BaseCategoryTrademark>()
                .eq("category3_id",category3Id).eq("trademark_id",trademarkId));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void save(CategoryTrademarkVo categoryTrademarkVo) {
        //  获取到品牌Id 集合数据
        List<Long> trademarkIdList = categoryTrademarkVo.getTrademarkIdList();
        //  判断
        if (!CollectionUtils.isEmpty(trademarkIdList)){
            //  做映射关系
            List<BaseCategoryTrademark> baseCategoryTrademarkList = trademarkIdList.stream().map(trademarkId -> {
                //  创建一个分类Id 与品牌的关联的对象
                BaseCategoryTrademark baseCategoryTrademark = new BaseCategoryTrademark();
                baseCategoryTrademark.setCategory3Id(categoryTrademarkVo.getCategory3Id());
                baseCategoryTrademark.setTrademarkId(trademarkId);
                return baseCategoryTrademark;
            }).collect(Collectors.toList());
            //将集合数据保存到数据库
            this.saveBatch(baseCategoryTrademarkList);
            }
        }
//        @Override
//        public List<BaseTrademark> findCurrentTrademarkList(Long category3Id) {
//            //  哪些是关联的品牌Id
//            QueryWrapper<BaseCategoryTrademark> baseCategoryTrademarkQueryWrapper = new QueryWrapper<>();
//            baseCategoryTrademarkQueryWrapper.eq("category3_id",category3Id);
//            List<BaseCategoryTrademark> baseCategoryTrademarkList = baseCategoryTrademarkMapper.selectList(baseCategoryTrademarkQueryWrapper);
//
//            //  判断
//            if (!CollectionUtils.isEmpty(baseCategoryTrademarkList)){
//                //  找到关联的品牌Id 集合数据 {1,3}
//                List<Long> tradeMarkIdList = baseCategoryTrademarkList.stream().map(baseCategoryTrademark -> {
//                    return baseCategoryTrademark.getTrademarkId();
//                }).collect(Collectors.toList());
//                //  在所有的品牌Id 中将这些有关联的品牌Id 给过滤掉就可以！
//                //  select * from base_trademark; 外面 baseTrademarkMapper.selectList(null) {1,2,3,5}
//                List<BaseTrademark> baseTrademarkList = baseTrademarkMapper.selectList(null).stream().filter(baseTrademark -> {
//                    return !tradeMarkIdList.contains(baseTrademark.getId());
//                }).collect(Collectors.toList());
//                //  返回数据
//                return baseTrademarkList;
//            }
//            //  如果说这个三级分类Id 下 没有任何品牌！ 则获取到所有的品牌数据！
//            return baseTrademarkMapper.selectList(null);
//        }

}
